package com.wlr.study.leetcode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author lrwang
 * @version 1.0
 * @date 2021/7/1 22:36
 * 力扣百题
 */
public class HundredLeetCode {
    /**
     *
     * @param nums
     * @return max
     * 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
     */
    public static int maxSubArray(int[] nums) {
        int res=nums[0];
        int sum = 0;
        for (int num : nums) {
            if (sum > 0)
                sum += num;
            else
                sum = num;
            res = Math.max(res, sum);
        }
        return res;
    }

    /**
     *
     * @param root
     * @return
     */
    public static List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        blTree(root, res);
        return res;

    }

    /**
     * 中序遍历二叉树
     * @param root
     * @param result
     */
    public static void blTree(TreeNode root,List<Integer> result){
        if (root==null){
            return ;
        }
        blTree(root.left,result);
        result.add(root.val);
        blTree(root.right,result);
    }

    /**
     * 给定一个二叉树，检查它是否是镜像对称的。
     * @param root
     * @return
     */
    public static boolean isSymmetric(TreeNode root) {
        return blTree(root,root);
    }

    public static boolean blTree(TreeNode left,TreeNode right){
        if (left == null && right == null) {
            return true;
        }
        if (left == null || right == null) {
            return false;
        }
        return left.val==right.val&&blTree(left.left,left.right)&&blTree(left.right,right.left);
    }

    public static ListNode mergeKLists(ListNode[] lists) {
        List<Integer> list=new LinkedList<>();
        for(ListNode l:lists){
            while(l!=null){
                list.add(l.val);
                l=l.next;
            }
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        return null;
    }
    public static void main(String[] args) {
        int[] nums={0};
        System.out.println(maxSubArray(nums));
        TreeNode root=new TreeNode(1);
        TreeNode right=new TreeNode(2);
        TreeNode left=new TreeNode(3);
        root.right=right;
        right.left=left;
        System.out.println(inorderTraversal(root));


        ListNode listNode1=new ListNode(1);
        ListNode listNode2=new ListNode(4);
        ListNode listNode3=new ListNode(5);
        listNode1.next=listNode2;
        listNode2.next=listNode3;
        ListNode listNode4=new ListNode(1);
        ListNode listNode5=new ListNode(3);
        ListNode listNode6=new ListNode(4);
        listNode4.next=listNode5;
        listNode5.next=listNode6;
        ListNode listNode8=new ListNode(2);
        ListNode listNode9=new ListNode(6);
        listNode8.next=listNode9;
        ListNode[] lists={listNode1,listNode4,listNode8};
        mergeKLists(lists);
    }
}
